home *** CD-ROM | disk | FTP | other *** search
/ Die Speccy' 97 / Die Speccy' 97.iso / amiga_system / the_aminet / comm / bbs / wwbbs31_source.lha / WWBBS / Library / messages.c < prev    next >
C/C++ Source or Header  |  1995-01-04  |  7KB  |  321 lines
  1. #include "wwbbs.h"
  2. #include "messages.h"
  3.  
  4. __asm
  5. APTR OpenMessageGroup(register __a0 BYTE *path,register __a1 BYTE *name,register __d0 LONG type)
  6.     {
  7.         APTR ret=NULL;
  8.         BYTE group[41];
  9.         strcpy(group,"");
  10.         if(!path && !name)
  11.             strcpy(group,"email");
  12.         else
  13.             GetConfigTags(CFGTAG_Path,path,CFGTAG_Name,name,MBTAG_Group,group,TAG_END);
  14.         if(strlen(group))
  15.             {
  16.                 struct MessageGroupNode *gnode;
  17.                 {
  18.                     BOOL exists=FALSE;
  19.                     ObtainSemaphoreShared(&MessageGroupSemaphore);
  20.                     if(FindName(&MessageGroupList,group))
  21.                         exists=TRUE;
  22.                     ReleaseSemaphore(&MessageGroupSemaphore);
  23.                     if(!exists)
  24.                         LoadMessageGroup(group);
  25.                 }
  26.                 ObtainSemaphoreShared(&MessageGroupSemaphore);
  27.                 if(gnode=(struct MessageGroupNode *) FindName(&MessageGroupList,group))
  28.                     {
  29.                         if(type==EXCLUSIVE_LOCK)
  30.                             ObtainSemaphore(&gnode->mgn_Semaphore);
  31.                         else
  32.                             ObtainSemaphoreShared(&gnode->mgn_Semaphore);
  33.                         ObtainSemaphore(&gnode->mgn_UsageCountSemaphore);
  34.                         gnode->mgn_UsageCount++;
  35.                         ReleaseSemaphore(&gnode->mgn_UsageCountSemaphore);
  36.                         ret=gnode;
  37.                     }
  38.                 else
  39.                     ReleaseSemaphore(&MessageGroupSemaphore);
  40.             }
  41.         return(ret);
  42.     }
  43.  
  44. __asm
  45. void CloseMessageGroup(register __a0 struct MessageGroupNode *gnode)
  46.     {
  47.         ObtainSemaphore(&gnode->mgn_UsageCountSemaphore);
  48.         gnode->mgn_UsageCount--;
  49.         ReleaseSemaphore(&gnode->mgn_UsageCountSemaphore);
  50.         ReleaseSemaphore(&gnode->mgn_Semaphore);
  51.         ReleaseSemaphore(&MessageGroupSemaphore);
  52.     }
  53.  
  54. __asm
  55. ULONG GetMessage(register __a0 struct MessageGroupNode *gnode,register __a1 struct TagItem *tags_orig)
  56.     {
  57.         ULONG ret=0;
  58.         ULONG id=0;
  59.         BOOL exists=FALSE;
  60.         {
  61.             struct TagItem *tags;
  62.             if(tags=CloneTagItems(tags_orig))
  63.                 {
  64.                     if(FilterTagItems(tags,msg_get_tags,TAGFILTER_AND))
  65.                         {
  66.                             struct TagItem *tstate,*tag;
  67.                             APTR data;
  68.                             tstate=tags;
  69.                             while(tag=NextTagItem(&tstate))
  70.                                 {
  71.                                     data=(APTR) tag->ti_Data;
  72.                                     switch(tag->ti_Tag)
  73.                                         {
  74.                                             case MSGTAG_ID:
  75.                                                 id=(ULONG) data;
  76.                                                 break;
  77.                                             case MSGTAG_Exists:
  78.                                                 exists=(BOOL) data;
  79.                                                 break;
  80.                                         }
  81.                                 }
  82.                         }
  83.                     FreeTagItems(tags);
  84.                 }
  85.         }
  86.         {
  87.             if(id)
  88.                 {
  89.                     struct MessageNode *node=NULL;
  90.                     if(node=GetMessageNode(gnode,id))
  91.                         {
  92.                             if(exists) ret++;
  93.                             ret+=GetMessageFields(node,tags_orig);
  94.                         }
  95.                 }
  96.         }
  97.         return(ret);
  98.     }
  99.  
  100. ULONG GetMessageTags(struct MessageGroupNode *gnode,Tag tag,...)
  101.     {
  102.         return(GetMessage(gnode,(struct TagItem *) &tag));
  103.     }
  104.  
  105. __asm
  106. ULONG SetMessage(register __a0 struct MessageGroupNode *gnode,register __a1 struct TagItem *tags_orig)
  107.     {
  108.         ULONG ret=0;
  109.         ULONG id=0;
  110.         BOOL forcesave=FALSE,dontsave=FALSE;
  111.         {
  112.             struct TagItem *tags;
  113.             if(tags=CloneTagItems(tags_orig))
  114.                 {
  115.                     if(FilterTagItems(tags,msg_set_tags,TAGFILTER_AND))
  116.                         {
  117.                             struct TagItem *tstate,*tag;
  118.                             APTR data;
  119.                             tstate=tags;
  120.                             while(tag=NextTagItem(&tstate))
  121.                                 {
  122.                                     data=(APTR) tag->ti_Data;
  123.                                     switch(tag->ti_Tag)
  124.                                         {
  125.                                             case MSGTAG_ID:
  126.                                                 id=(ULONG) data;
  127.                                                 break;
  128.                                             case MSGTAG_ForceSave:
  129.                                                 forcesave=(BOOL) data;
  130.                                                 break;
  131.                                             case MSGTAG_DontSave:
  132.                                                 dontsave=(BOOL) data;
  133.                                                 break;
  134.                                         }
  135.                                 }
  136.                         }
  137.                     FreeTagItems(tags);
  138.                 }
  139.         }
  140.         {
  141.             if(id)
  142.                 {
  143.                     struct MessageNode *node=NULL;
  144.                     if(node=GetMessageNode(gnode,id))
  145.                         ret+=SetMessageFields(node,tags_orig);
  146.                 }
  147.         }
  148.         if((ret && !dontsave) || forcesave)
  149.             SaveMessageGroup(gnode);
  150.         return(ret);
  151.     }
  152.  
  153. ULONG SetMessageTags(struct MessageGroupNode *gnode,Tag tag,...)
  154.     {
  155.         return(SetMessage(gnode,(struct TagItem *) &tag));
  156.     }
  157.  
  158. __asm
  159. ULONG AddMessage(register __a0 struct MessageGroupNode *gnode,register __a1 struct TagItem *tags_orig)
  160.     {
  161.         ULONG ret=0;
  162.         ULONG replyto=0;
  163.         BOOL dontsave=FALSE;
  164.         {
  165.             struct TagItem *tags;
  166.             if(tags=CloneTagItems(tags_orig))
  167.                 {
  168.                     if(FilterTagItems(tags,msg_add_tags,TAGFILTER_AND))
  169.                         {
  170.                             struct TagItem *tstate,*tag;
  171.                             APTR data;
  172.                             tstate=tags;
  173.                             while(tag=NextTagItem(&tstate))
  174.                                 {
  175.                                     data=(APTR) tag->ti_Data;
  176.                                     switch(tag->ti_Tag)
  177.                                         {
  178.                                             case MSGTAG_ReplyTo:
  179.                                                 replyto=(ULONG) data;
  180.                                                 break;
  181.                                             case MSGTAG_DontSave:
  182.                                                 dontsave=(BOOL) data;
  183.                                                 break;
  184.                                         }
  185.                                 }
  186.                         }
  187.                     FreeTagItems(tags);
  188.                 }
  189.         }
  190.         {
  191.             struct MessageNode *node;
  192.             if(node=AllocVec(sizeof(struct MessageNode),MEMF_CLEAR))
  193.                 {
  194.                     node->mn_ID=gnode->mgn_MessageCount+1;
  195.                     if(replyto)
  196.                         {
  197.                             ULONG thread=0;
  198.                             if(GetMessageTags(gnode,MSGTAG_ID,replyto,MSGTAG_Thread,&thread,TAG_END))
  199.                                 node->mn_Thread=thread;
  200.                         }
  201.                     else
  202.                         node->mn_Thread=gnode->mgn_ThreadCount+1;
  203.                     DateStamp(&node->mn_Date);
  204.                     AddTail(&gnode->mgn_Messages,(struct Node *) node);
  205.                     gnode->mgn_MessageCount++;
  206.                     if(!replyto)
  207.                         gnode->mgn_ThreadCount++;
  208.                     ret=node->mn_ID;
  209.                 }
  210.         }
  211.         if(ret && !dontsave)
  212.             SaveMessageGroup(gnode);
  213.         return(ret);
  214.     }
  215.  
  216. ULONG AddMessageTags(struct MessageGroupNode *gnode,Tag tag,...)
  217.     {
  218.         return(AddMessage(gnode,(struct TagItem *) &tag));
  219.     }
  220.  
  221. __asm
  222. BOOL RemMessage(register __a0 struct MessageGroupNode *gnode,register __a1 struct TagItem *tags_orig)
  223.     {
  224.         BOOL ret=FALSE;
  225.         ULONG id=0;
  226.         BOOL dontsave=FALSE;
  227.         {
  228.             struct TagItem *tags;
  229.             if(tags=CloneTagItems(tags_orig))
  230.                 {
  231.                     if(FilterTagItems(tags,msg_rem_tags,TAGFILTER_AND))
  232.                         {
  233.                             struct TagItem *tstate,*tag;
  234.                             APTR data;
  235.                             tstate=tags;
  236.                             while(tag=NextTagItem(&tstate))
  237.                                 {
  238.                                     data=(APTR) tag->ti_Data;
  239.                                     switch(tag->ti_Tag)
  240.                                         {
  241.                                             case MSGTAG_ID:
  242.                                                 id=(ULONG) data;
  243.                                                 break;
  244.                                             case MSGTAG_DontSave:
  245.                                                 dontsave=(BOOL) data;
  246.                                                 break;
  247.                                         }
  248.                                 }
  249.                         }
  250.                     FreeTagItems(tags);
  251.                 }
  252.         }
  253.         {
  254.             struct MessageNode *node;
  255.             if(node=GetMessageNode(gnode,id))
  256.                 {
  257.                     Remove((struct Node *) node);
  258.                     FreeVec(node);
  259.                     ret=TRUE;
  260.                 }
  261.         }
  262.         if(ret && !dontsave)
  263.             SaveMessageGroup(gnode);
  264.         return(ret);
  265.     }
  266.  
  267. BOOL RemMessageTags(struct MessageGroupNode *gnode,Tag tag,...)
  268.     {
  269.         return(RemMessage(gnode,(struct TagItem *) &tag));
  270.     }
  271.  
  272. __asm
  273. ULONG GetNextMessage(register __a0 struct MessageGroupNode *gnode,register __d0 ULONG id)
  274.     {
  275.         ULONG ret=0;
  276.         struct MessageNode *node;
  277.         if(node=GetMessageNode(gnode,id))
  278.             {
  279.                 node=(struct MessageNode *) node->mn_Node.ln_Succ;
  280.                 if(node->mn_Node.ln_Succ)
  281.                     ret=node->mn_ID;
  282.             }
  283.         else
  284.             {
  285.                 for(node=(struct MessageNode *) gnode->mgn_Messages.lh_Head;node->mn_Node.ln_Succ;node=(struct MessageNode *) node->mn_Node.ln_Succ)
  286.                     {
  287.                         if(node->mn_ID>id)
  288.                             {
  289.                                 ret=node->mn_ID;
  290.                                 break;
  291.                             }
  292.                     }
  293.             }
  294.         return(ret);
  295.     }
  296.  
  297. __asm
  298. ULONG GetPreviousMessage(register __a0 struct MessageGroupNode *gnode,register __d0 ULONG id)
  299.     {
  300.         ULONG ret=0;
  301.         struct MessageNode *node;
  302.         if(node=GetMessageNode(gnode,id))
  303.             {
  304.                 node=(struct MessageNode *) node->mn_Node.ln_Pred;
  305.                 if(node->mn_Node.ln_Pred)
  306.                     ret=node->mn_ID;
  307.             }
  308.         else
  309.             {
  310.                 for(node=(struct MessageNode *) gnode->mgn_Messages.lh_TailPred;node->mn_Node.ln_Pred;node=(struct MessageNode *) node->mn_Node.ln_Pred)
  311.                     {
  312.                         if(node->mn_ID<id)
  313.                             {
  314.                                 ret=node->mn_ID;
  315.                                 break;
  316.                             }
  317.                     }
  318.             }
  319.         return(ret);
  320.     }
  321.